/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package controladores;

import controladores.exceptions.NonexistentEntityException;
import entidades.IngresoRepuesto;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import entidades.LoteIngresoRepuesto;
import entidades.Repuesto;
import entidades.Usuario;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

/**
 *
 * @author g
 */
public class IngresoRepuestoJpaController implements Serializable {

    public IngresoRepuestoJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(IngresoRepuesto ingresoRepuesto) {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            LoteIngresoRepuesto loteIngresoRepuesto = ingresoRepuesto.getLoteIngresoRepuesto();
            if (loteIngresoRepuesto != null) {
                loteIngresoRepuesto = em.getReference(loteIngresoRepuesto.getClass(), loteIngresoRepuesto.getId());
                ingresoRepuesto.setLoteIngresoRepuesto(loteIngresoRepuesto);
            }
            Repuesto repuesto = ingresoRepuesto.getRepuesto();
            if (repuesto != null) {
                repuesto = em.getReference(repuesto.getClass(), repuesto.getId());
                ingresoRepuesto.setRepuesto(repuesto);
            }
            Usuario responsable = ingresoRepuesto.getResponsable();
            if (responsable != null) {
                responsable = em.getReference(responsable.getClass(), responsable.getId());
                ingresoRepuesto.setResponsable(responsable);
            }
            em.persist(ingresoRepuesto);
            if (loteIngresoRepuesto != null) {
                loteIngresoRepuesto.getLs_ingresos().add(ingresoRepuesto);
                loteIngresoRepuesto = em.merge(loteIngresoRepuesto);
            }
            if (repuesto != null) {
                repuesto.getLs_ingresos().add(ingresoRepuesto);
                repuesto = em.merge(repuesto);
            }
            if (responsable != null) {
                IngresoRepuesto oldIngresoRepuestoOfResponsable = responsable.getIngresoRepuesto();
                if (oldIngresoRepuestoOfResponsable != null) {
                    oldIngresoRepuestoOfResponsable.setResponsable(null);
                    oldIngresoRepuestoOfResponsable = em.merge(oldIngresoRepuestoOfResponsable);
                }
                responsable.setIngresoRepuesto(ingresoRepuesto);
                responsable = em.merge(responsable);
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(IngresoRepuesto ingresoRepuesto) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            IngresoRepuesto persistentIngresoRepuesto = em.find(IngresoRepuesto.class, ingresoRepuesto.getId());
            LoteIngresoRepuesto loteIngresoRepuestoOld = persistentIngresoRepuesto.getLoteIngresoRepuesto();
            LoteIngresoRepuesto loteIngresoRepuestoNew = ingresoRepuesto.getLoteIngresoRepuesto();
            Repuesto repuestoOld = persistentIngresoRepuesto.getRepuesto();
            Repuesto repuestoNew = ingresoRepuesto.getRepuesto();
            Usuario responsableOld = persistentIngresoRepuesto.getResponsable();
            Usuario responsableNew = ingresoRepuesto.getResponsable();
            if (loteIngresoRepuestoNew != null) {
                loteIngresoRepuestoNew = em.getReference(loteIngresoRepuestoNew.getClass(), loteIngresoRepuestoNew.getId());
                ingresoRepuesto.setLoteIngresoRepuesto(loteIngresoRepuestoNew);
            }
            if (repuestoNew != null) {
                repuestoNew = em.getReference(repuestoNew.getClass(), repuestoNew.getId());
                ingresoRepuesto.setRepuesto(repuestoNew);
            }
            if (responsableNew != null) {
                responsableNew = em.getReference(responsableNew.getClass(), responsableNew.getId());
                ingresoRepuesto.setResponsable(responsableNew);
            }
            ingresoRepuesto = em.merge(ingresoRepuesto);
            if (loteIngresoRepuestoOld != null && !loteIngresoRepuestoOld.equals(loteIngresoRepuestoNew)) {
                loteIngresoRepuestoOld.getLs_ingresos().remove(ingresoRepuesto);
                loteIngresoRepuestoOld = em.merge(loteIngresoRepuestoOld);
            }
            if (loteIngresoRepuestoNew != null && !loteIngresoRepuestoNew.equals(loteIngresoRepuestoOld)) {
                loteIngresoRepuestoNew.getLs_ingresos().add(ingresoRepuesto);
                loteIngresoRepuestoNew = em.merge(loteIngresoRepuestoNew);
            }
            if (repuestoOld != null && !repuestoOld.equals(repuestoNew)) {
                repuestoOld.getLs_ingresos().remove(ingresoRepuesto);
                repuestoOld = em.merge(repuestoOld);
            }
            if (repuestoNew != null && !repuestoNew.equals(repuestoOld)) {
                repuestoNew.getLs_ingresos().add(ingresoRepuesto);
                repuestoNew = em.merge(repuestoNew);
            }
            if (responsableOld != null && !responsableOld.equals(responsableNew)) {
                responsableOld.setIngresoRepuesto(null);
                responsableOld = em.merge(responsableOld);
            }
            if (responsableNew != null && !responsableNew.equals(responsableOld)) {
                IngresoRepuesto oldIngresoRepuestoOfResponsable = responsableNew.getIngresoRepuesto();
                if (oldIngresoRepuestoOfResponsable != null) {
                    oldIngresoRepuestoOfResponsable.setResponsable(null);
                    oldIngresoRepuestoOfResponsable = em.merge(oldIngresoRepuestoOfResponsable);
                }
                responsableNew.setIngresoRepuesto(ingresoRepuesto);
                responsableNew = em.merge(responsableNew);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Long id = ingresoRepuesto.getId();
                if (findIngresoRepuesto(id) == null) {
                    throw new NonexistentEntityException("The ingresoRepuesto with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Long id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            IngresoRepuesto ingresoRepuesto;
            try {
                ingresoRepuesto = em.getReference(IngresoRepuesto.class, id);
                ingresoRepuesto.getId();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The ingresoRepuesto with id " + id + " no longer exists.", enfe);
            }
            LoteIngresoRepuesto loteIngresoRepuesto = ingresoRepuesto.getLoteIngresoRepuesto();
            if (loteIngresoRepuesto != null) {
                loteIngresoRepuesto.getLs_ingresos().remove(ingresoRepuesto);
                loteIngresoRepuesto = em.merge(loteIngresoRepuesto);
            }
            Repuesto repuesto = ingresoRepuesto.getRepuesto();
            if (repuesto != null) {
                repuesto.getLs_ingresos().remove(ingresoRepuesto);
                repuesto = em.merge(repuesto);
            }
            Usuario responsable = ingresoRepuesto.getResponsable();
            if (responsable != null) {
                responsable.setIngresoRepuesto(null);
                responsable = em.merge(responsable);
            }
            em.remove(ingresoRepuesto);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<IngresoRepuesto> findIngresoRepuestoEntities() {
        return findIngresoRepuestoEntities(true, -1, -1);
    }

    public List<IngresoRepuesto> findIngresoRepuestoEntities(int maxResults, int firstResult) {
        return findIngresoRepuestoEntities(false, maxResults, firstResult);
    }

    private List<IngresoRepuesto> findIngresoRepuestoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(IngresoRepuesto.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public IngresoRepuesto findIngresoRepuesto(Long id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(IngresoRepuesto.class, id);
        } finally {
            em.close();
        }
    }

    public int getIngresoRepuestoCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<IngresoRepuesto> rt = cq.from(IngresoRepuesto.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
